require('dotenv').config();
const express = require('express');
const cors = require('cors');
const morgan = require('morgan');
const bodyParser = require('body-parser');
const path = require('path');
const fs = require('fs');

// 路由导入（添加容错处理）
let userRoutes;
try {
  userRoutes = require('./routes/userRoutes');
} catch (err) {
  console.error('用户路由文件加载失败，请检查 routes/userRoutes.js 是否存在：', err.message);
  userRoutes = express.Router(); // 临时创建空路由，避免服务器崩溃
}

let shopRoutes;
try {
  shopRoutes = require('./routes/shopRoutes');
} catch (err) {
  console.error('餐厅路由文件加载失败，请检查 routes/shopRoutes.js 是否存在：', err.message);
  shopRoutes = express.Router(); // 临时创建空路由
}

// 导入桌位路由
let tableRoutes;
try {
  tableRoutes = require('./routes/tableRoutes');
  console.log('✅ 桌位路由加载成功');
} catch (err) {
  console.error('❌ 桌位路由文件加载失败，请检查 routes/tableRoutes.js 是否存在：', err.message);
  tableRoutes = express.Router(); // 临时创建空路由
  
  // 添加基本路由避免404
  tableRoutes.get('/shop/:shopId/tables', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '桌位功能暂不可用，请检查服务器配置' 
    });
  });
  
  tableRoutes.post('/table/:tableId/select', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '桌位选择功能暂不可用，请检查服务器配置' 
    });
  });
}

// 导入菜品路由
let dishRoutes;
try {
  dishRoutes = require('./routes/dishRoutes');
  console.log('✅ 菜品路由加载成功');
} catch (err) {
  console.error('❌ 菜品路由文件加载失败，请检查 routes/dishRoutes.js 是否存在：', err.message);
  dishRoutes = express.Router(); // 临时创建空路由
  
  // 添加基本路由避免404
  dishRoutes.get('/shop/:shopId/categories', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '菜品分类功能暂不可用，请检查服务器配置' 
    });
  });
  
  dishRoutes.get('/shop/:shopId/categories/:categoryId/dishes', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '菜品列表功能暂不可用，请检查服务器配置' 
    });
  });
}

// 导入分类路由
let categoryRoutes;
try {
  categoryRoutes = require('./routes/categoryRoutes');
  console.log('✅ 分类路由加载成功');
} catch (err) {
  console.error('❌ 分类路由文件加载失败，请检查 routes/categoryRoutes.js 是否存在：', err.message);
  categoryRoutes = express.Router();
}

// 导入地址路由
let addressRoutes;
try {
  console.log('🔍 开始加载地址路由...');
  addressRoutes = require('./routes/addressRoutes');
  console.log('✅ 地址路由加载成功');
} catch (err) {
  console.error('❌ 地址路由文件加载失败：', err.message);
  console.error('错误详情:', err);
  addressRoutes = express.Router();
  
  // 添加基本地址路由避免404
  addressRoutes.get('/', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '地址功能暂不可用，请检查服务器配置' 
    });
  });
  
  addressRoutes.get('/default', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '地址功能暂不可用，请检查服务器配置' 
    });
  });
  
  addressRoutes.post('/', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '地址功能暂不可用，请检查服务器配置' 
    });
  });
  
  addressRoutes.put('/:id', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '地址功能暂不可用，请检查服务器配置' 
    });
  });
  
  addressRoutes.delete('/:id', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '地址功能暂不可用，请检查服务器配置' 
    });
  });
  
  addressRoutes.patch('/:id/set-default', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '地址功能暂不可用，请检查服务器配置' 
    });
  });
}

// 导入订单路由（简化调试信息）
let orderRoutes;
try {
  console.log('🔍 开始加载订单路由...');
  orderRoutes = require('./routes/orderRoutes');
  console.log('✅ 订单路由加载成功');
  
} catch (err) {
  console.error('❌ 订单路由文件加载失败：', err.message);
  console.error('错误堆栈:', err.stack);
  orderRoutes = express.Router(); // 临时创建空路由
  
  // 添加基本订单路由避免404
  orderRoutes.post('/create', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '订单创建功能暂不可用，请检查服务器配置' 
    });
  });
  
  orderRoutes.get('/', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '获取用户订单功能暂不可用，请检查服务器配置' 
    });
  });
  
  orderRoutes.get('/:order_id', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '获取订单详情功能暂不可用，请检查服务器配置' 
    });
  });
  
  orderRoutes.put('/:order_id/status', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '更新订单状态功能暂不可用，请检查服务器配置' 
    });
  });

  orderRoutes.patch('/:order_id/cancel', (req, res) => {
    res.status(503).json({ 
      success: false,
      message: '取消订单功能暂不可用，请检查服务器配置' 
    });
  });
}

// 创建Express应用
const app = express();
const PORT = process.env.PORT || 3000;

// 创建上传目录
const uploadDir = path.join(__dirname, 'uploads');
if (!fs.existsSync(uploadDir)) {
  fs.mkdirSync(uploadDir, { recursive: true });
}

// 中间件配置
app.use(cors({
  origin: "*", // 开发环境可临时用*，生产环境需指定具体域名（如鸿蒙应用域名）
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'], // 添加所有支持的方法
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With']
}));
app.use(morgan('dev'));
app.use(bodyParser.json({ limit: '10mb' })); // 增加请求体大小限制
app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
app.use('/uploads', express.static(uploadDir));

// 健康检查路由
app.get('/health', (req, res) => {
  res.json({ 
    success: true,
    message: '服务运行正常',
    timestamp: new Date().toISOString()
  });
});

// 路由配置
app.use('/api/users', userRoutes); // 用户登录注册路由
app.use('/api/shops', shopRoutes); // 餐厅路由
app.use('/api', tableRoutes); // 桌位路由
app.use('/api', dishRoutes); // 菜品路由
app.use('/api', categoryRoutes); // 分类路由
app.use('/api/addresses', addressRoutes); // 地址路由
app.use('/api/orders', orderRoutes); // 订单路由

// 根路由
app.get('/', (req, res) => {
  res.json({
    success: true,
    message: '在线点餐系统API正在运行中...',
    version: '1.0.0',
    timestamp: new Date().toISOString(),
    endpoints: {
      users: '/api/users',
      shops: '/api/shops',
      tables: '/api/shop/:shopId/tables',
      dishes: '/api/shop/:shopId/categories/:categoryId/dishes',
      categories: '/api/shop/:shopId/categories',
      addresses: '/api/addresses',
      orders: '/api/orders'
    }
  });
});

// 404 错误处理
app.use((req, res) => {
  res.status(404).json({ 
    success: false,
    message: '接口不存在，请检查请求路径',
    path: req.path
  });
});

// 全局错误处理
app.use((err, req, res, next) => {
  console.error('全局错误处理:', err.stack);
  res.status(500).json({
    success: false,
    message: '服务器内部错误',
    error: process.env.NODE_ENV === 'development' ? err.message : '请联系管理员'
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`🚀 服务器运行在 http://localhost:${PORT}`);
  console.log('📋 可用接口：');
  console.log('   👤 用户相关：');
  console.log('     - POST /api/users/register (用户注册)');
  console.log('     - POST /api/users/login (用户登录)');
  console.log('   🏪 餐厅相关：');
  console.log('     - GET /api/shops (获取餐厅列表)');
  console.log('     - GET /api/shops/:id (获取餐厅详情)');
  console.log('   🪑 桌位相关：');
  console.log('     - GET /api/shop/:shopId/tables (获取桌位列表)');
  console.log('     - POST /api/table/:tableId/select (选择桌位)');
  console.log('     - POST /api/table/:tableId/release (释放桌位)');
  console.log('   🍽️ 菜品相关：');
  console.log('     - GET /api/shop/:shopId/categories (获取菜品分类)');
  console.log('     - GET /api/shop/:shopId/categories/:categoryId/dishes (获取分类下菜品)');
  console.log('   📍 地址相关：');
  console.log('     - GET /api/addresses (获取用户地址列表)');
  console.log('     - POST /api/addresses (创建地址)');
  console.log('     - PUT /api/addresses/:id (更新地址)');
  console.log('     - DELETE /api/addresses/:id (删除地址)');
  console.log('     - PATCH /api/addresses/:id/set-default (设置默认地址)');
  console.log('   📦 订单相关：');
  console.log('     - POST /api/orders/create (创建订单)');
  console.log('     - GET /api/orders (获取用户订单列表)');
  console.log('     - GET /api/orders/:order_id (获取订单详情)');
  console.log('     - PUT /api/orders/:order_id/status (更新订单状态)');
  console.log('     - PATCH /api/orders/:order_id/cancel (取消订单)');
  console.log('   🔍 其他：');
  console.log('     - GET /health (健康检查)');
  console.log('');
  console.log('💡 提示：确保前端请求的接口路径与上述路径一致');
});